home *** CD-ROM | disk | FTP | other *** search
/ Aminet 34 / Aminet 34 (2000)(Schatztruhe)[!][Dec 1999].iso / Aminet / dev / lang / Python152_Src.lha / Python152_Source / Modules / pcremodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-04-26  |  16.5 KB  |  690 lines
  1. /***********************************************************
  2. Copyright 1997 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* Pcre objects */
  33.  
  34. #include "Python.h"
  35.  
  36. #include <assert.h>
  37. #ifndef Py_eval_input
  38. /* For Python 1.4, graminit.h has to be explicitly included */
  39. #include "graminit.h"
  40. #define Py_eval_input eval_input
  41. #endif
  42.  
  43. #ifndef FOR_PYTHON
  44. #define FOR_PYTHON
  45. #endif
  46.  
  47. #include "pcre.h"
  48. #include "pcre-int.h"
  49.  
  50. static PyObject *ErrorObject;
  51.  
  52. typedef struct {
  53.     PyObject_HEAD
  54.     pcre *regex;
  55.     pcre_extra *regex_extra;
  56.         int num_groups;
  57. } PcreObject;
  58.  
  59. #include "protos/pcremodule.h"
  60.  
  61. staticforward PyTypeObject Pcre_Type;
  62.  
  63. #define PcreObject_Check(v)    ((v)->ob_type == &Pcre_Type)
  64. #define NORMAL            0
  65. #define CHARCLASS        1
  66. #define REPLACEMENT        2
  67.  
  68. #define CHAR             0
  69. #define MEMORY_REFERENCE     1
  70. #define SYNTAX             2
  71. #define NOT_SYNTAX         3
  72. #define SET            4
  73. #define WORD_BOUNDARY        5
  74. #define NOT_WORD_BOUNDARY    6
  75. #define BEGINNING_OF_BUFFER    7
  76. #define END_OF_BUFFER        8
  77. #define STRING                  9
  78.  
  79. static PcreObject *
  80. newPcreObject(arg)
  81.     PyObject *arg;
  82. {
  83.     PcreObject *self;
  84.     self = PyObject_NEW(PcreObject, &Pcre_Type);
  85.     if (self == NULL)
  86.         return NULL;
  87.     self->regex = NULL;
  88.     self->regex_extra = NULL;
  89.     return self;
  90. }
  91.  
  92. /* Pcre methods */
  93.  
  94. static void
  95. PyPcre_dealloc(self)
  96.     PcreObject *self;
  97. {
  98.     if (self->regex) free(self->regex);
  99.     if (self->regex_extra) free(self->regex_extra);
  100.     self->regex=NULL;
  101.     self->regex_extra=NULL;
  102.     PyMem_DEL(self);
  103. }
  104.  
  105.  
  106. static PyObject *
  107. PyPcre_exec(self, args)
  108.     PcreObject *self;
  109.     PyObject *args;
  110. {
  111.         char *string;
  112.     int stringlen, pos = 0, options=0, endpos = -1, i, count;
  113.     int offsets[100*2]; 
  114.     PyObject *list;
  115.  
  116.     if (!PyArg_ParseTuple(args, "t#|iiii", &string, &stringlen, &pos, &endpos, &options))
  117.         return NULL;
  118.     if (endpos == -1) {endpos = stringlen;}
  119.     count = pcre_exec(self->regex, self->regex_extra, 
  120.               string, endpos, pos, options,
  121.               offsets, sizeof(offsets)/sizeof(int) );
  122.     /* If an error occurred during the match, and an exception was raised,
  123.        just return NULL and leave the exception alone.  The most likely
  124.        problem to cause this would be running out of memory for
  125.        the failure stack. */
  126.     if (PyErr_Occurred())
  127.     {
  128.         return NULL;
  129.     }
  130.     if (count==PCRE_ERROR_NOMATCH) {Py_INCREF(Py_None); return Py_None;}
  131.     if (count<0)
  132.     {
  133.         PyObject *errval = Py_BuildValue("si", "Regex execution error", count);
  134.         PyErr_SetObject(ErrorObject, errval);
  135.         Py_XDECREF(errval);
  136.         return NULL;
  137.     }
  138.     
  139.     list=PyList_New(self->num_groups+1);
  140.     if (list==NULL) return NULL;
  141.     for(i=0; i<=self->num_groups; i++)
  142.     {
  143.         PyObject *v;
  144.         int start=offsets[i*2], end=offsets[i*2+1];
  145.         /* If the group wasn't affected by the match, return -1, -1 */
  146.         if (start<0 || count<=i) 
  147.         {start=end=-1;}
  148.         v=Py_BuildValue("ii", start, end);
  149.         if (v==NULL) {Py_DECREF(list); return NULL;}
  150.         PyList_SetItem(list, i, v);
  151.     }
  152.     return list;
  153. }
  154.  
  155. static PyMethodDef Pcre_methods[] = {
  156.     {"match",    (PyCFunction)PyPcre_exec,    1},
  157.     {NULL,        NULL}        /* sentinel */
  158. };
  159.  
  160. static PyObject *
  161. PyPcre_getattr(self, name)
  162.     PcreObject *self;
  163.     char *name;
  164. {
  165.     return Py_FindMethod(Pcre_methods, (PyObject *)self, name);
  166. }
  167.  
  168.  
  169. staticforward PyTypeObject Pcre_Type = {
  170.     PyObject_HEAD_INIT(&PyType_Type)
  171.     0,            /*ob_size*/
  172.     "Pcre",            /*tp_name*/
  173.     sizeof(PcreObject),    /*tp_basicsize*/
  174.     0,            /*tp_itemsize*/
  175.     /* methods */
  176.     (destructor)PyPcre_dealloc, /*tp_dealloc*/
  177.     0,            /*tp_print*/
  178.     (getattrfunc)PyPcre_getattr, /*tp_getattr*/
  179.     0,                      /*tp_setattr*/
  180.     0,            /*tp_compare*/
  181.     0,            /*tp_repr*/
  182.     0,            /*tp_as_number*/
  183.     0,            /*tp_as_sequence*/
  184.     0,            /*tp_as_mapping*/
  185.     0,            /*tp_hash*/
  186. };
  187. /* --------------------------------------------------------------------- */
  188.  
  189. static PyObject *
  190. PyPcre_compile(self, args)
  191.     PyObject *self; /* Not used */
  192.     PyObject *args;
  193. {
  194.     PcreObject *rv;
  195.     PyObject *dictionary;
  196.     char *pattern;
  197.     const char *error;
  198.     
  199.     int options, erroroffset;
  200.     if (!PyArg_ParseTuple(args, "siO!", &pattern, &options,
  201.                   &PyDict_Type, &dictionary))
  202.         return NULL;
  203.     rv = newPcreObject(args);
  204.     if ( rv == NULL )
  205.         return NULL;
  206.  
  207.     rv->regex = pcre_compile((char*)pattern, options, 
  208.                  &error, &erroroffset, dictionary);
  209.     if (rv->regex==NULL) 
  210.     {
  211.         PyMem_DEL(rv);
  212.         if (!PyErr_Occurred())
  213.         {
  214.             PyObject *errval = Py_BuildValue("si", error, erroroffset);
  215.             PyErr_SetObject(ErrorObject, errval);
  216.             Py_XDECREF(errval);
  217.         }
  218.         return NULL;
  219.     }
  220.     rv->regex_extra=pcre_study(rv->regex, 0, &error);
  221.     if (rv->regex_extra==NULL && error!=NULL) 
  222.     {
  223.         PyObject *errval = Py_BuildValue("si", error, 0);
  224.         PyMem_DEL(rv);
  225.         PyErr_SetObject(ErrorObject, errval);
  226.         Py_XDECREF(errval);
  227.         return NULL;
  228.     }
  229.         rv->num_groups = pcre_info(rv->regex, NULL, NULL);
  230.     if (rv->num_groups<0) 
  231.     {
  232.         PyObject *errval = Py_BuildValue("si", error, rv->num_groups);
  233.         PyErr_SetObject(ErrorObject, errval);
  234.         Py_XDECREF(errval);
  235.         PyMem_DEL(rv);
  236.         return NULL;
  237.     }
  238.     return (PyObject *)rv;
  239. }
  240.  
  241. static PyObject *
  242. PyPcre_expand_escape(pattern, pattern_len, indexptr, typeptr)
  243.     unsigned char *pattern;
  244.     int pattern_len, *indexptr, *typeptr;
  245. {
  246.     unsigned char c;
  247.     int index = *indexptr;
  248.   
  249.     if (pattern_len<=index)
  250.     {
  251.         PyErr_SetString(ErrorObject, "escape ends too soon");
  252.         return NULL;
  253.     }
  254.     c=pattern[index]; index++;
  255.     *typeptr=CHAR;
  256.  
  257.     switch (c)
  258.     {
  259.     case('t'):
  260.         *indexptr=index;
  261.         return Py_BuildValue("c", (char)9);
  262.     case('n'):
  263.         *indexptr = index;
  264.         return Py_BuildValue("c", (char)10);
  265.     case('v'):
  266.         *indexptr = index;
  267.         return Py_BuildValue("c", (char)11);
  268.     case('r'):
  269.         *indexptr = index;
  270.         return Py_BuildValue("c", (char)13);
  271.     case('f'):
  272.         *indexptr = index;
  273.         return Py_BuildValue("c", (char)12);
  274.     case('a'):
  275.         *indexptr = index;
  276.         return Py_BuildValue("c", (char)7);
  277.     case('b'):
  278.         *indexptr=index;
  279.         return Py_BuildValue("c", (char)8);
  280.     case('\\'):
  281.         *indexptr=index;
  282.         return Py_BuildValue("c", '\\');
  283.  
  284.     case('x'):
  285.     {
  286.         int x, ch, end;
  287.  
  288.         x = 0; end = index;
  289.         while ( (end<pattern_len && pcre_ctypes[ pattern[end] ] & ctype_xdigit) != 0)
  290.         {
  291.             ch = pattern[end];
  292.             x = x * 16 + pcre_lcc[ch] -
  293.                 (((pcre_ctypes[ch] & ctype_digit) != 0)? '0' : 'W');
  294.             x &= 255;
  295.             end++;
  296.         }
  297.         if (end==index)
  298.         {
  299.             PyErr_SetString(ErrorObject, "\\x must be followed by hex digits");
  300.             return NULL;
  301.         }
  302.         *indexptr = end;
  303.         return Py_BuildValue("c", (char)x);
  304.     }
  305.     break;
  306.  
  307.     case('E'):    case('G'):    case('L'):    case('Q'):
  308.     case('U'):    case('l'):    case('u'):
  309.     {
  310.         char message[50];
  311.         sprintf(message, "\\%c is not allowed", c);
  312.         PyErr_SetString(ErrorObject, message);
  313.         return NULL;
  314.     }
  315.  
  316.     case('g'):
  317.     {
  318.         int end, i;
  319.         int group_num = 0, is_number=0;
  320.  
  321.         if (pattern_len<=index)
  322.         {
  323.             PyErr_SetString(ErrorObject, "unfinished symbolic reference");
  324.             return NULL;
  325.         }
  326.         if (pattern[index]!='<')
  327.         {
  328.             PyErr_SetString(ErrorObject, "missing < in symbolic reference");
  329.             return NULL;
  330.         }
  331.         index++;
  332.         end=index;
  333.         while (end<pattern_len && pattern[end]!='>')
  334.             end++;
  335.         if (end==pattern_len)
  336.         {
  337.             PyErr_SetString(ErrorObject, "unfinished symbolic reference");
  338.             return NULL;
  339.         }
  340.  
  341.         if (index==end)        /* Zero-length name */
  342.         {
  343.             /* XXX should include the text of the reference */
  344.             PyErr_SetString(ErrorObject, "zero-length symbolic reference");
  345.             return NULL;
  346.         }
  347.         if ((pcre_ctypes[pattern[index]] & ctype_digit)) /* First char. a digit */
  348.         {
  349.                 is_number = 1;
  350.             group_num = pattern[index] - '0';
  351.         }
  352.  
  353.         for(i=index+1; i<end; i++)
  354.         {
  355.                 if (is_number && 
  356.                 !(pcre_ctypes[pattern[i]] & ctype_digit) )
  357.             {
  358.                 /* XXX should include the text of the reference */
  359.                 PyErr_SetString(ErrorObject, "illegal non-digit character in \\g<...> starting with digit");
  360.                 return NULL;                   
  361.             }
  362.             else {group_num = group_num * 10 + pattern[i] - '0';}
  363.             if (!(pcre_ctypes[pattern[i]] & ctype_word) )
  364.             {
  365.                 /* XXX should include the text of the reference */
  366.                 PyErr_SetString(ErrorObject, "illegal symbolic reference");
  367.                 return NULL;
  368.             }
  369.         }    
  370.         
  371.         *typeptr = MEMORY_REFERENCE;
  372.         *indexptr = end+1;
  373.         /* If it's a number, return the integer value of the group */
  374.         if (is_number) return Py_BuildValue("i", group_num);
  375.         /* Otherwise, return a string containing the group name */
  376.         return Py_BuildValue("s#", pattern+index, end-index);
  377.     }
  378.     break;
  379.  
  380.     case('0'):
  381.     {
  382.         /* \0 always indicates an octal escape, so we consume up to 3
  383.            characters, as long as they're all octal digits */
  384.         int octval=0, i;
  385.         index--;
  386.         for(i=index;
  387.             i<=index+2 && i<pattern_len 
  388.                 && (pcre_ctypes[ pattern[i] ] & ctype_odigit );
  389.             i++)
  390.         {
  391.             octval = octval * 8 + pattern[i] - '0';
  392.         }
  393.         if (octval>255)
  394.         {
  395.             PyErr_SetString(ErrorObject, "octal value out of range");
  396.             return NULL;
  397.         }
  398.         *indexptr = i;
  399.         return Py_BuildValue("c", (unsigned char)octval);
  400.     }
  401.     break;
  402.     case('1'):    case('2'):    case('3'):    case('4'):
  403.     case('5'):    case('6'):    case('7'):    case('8'):
  404.     case('9'):
  405.     {
  406.         /* Handle \?, where ? is from 1 through 9 */
  407.         int value=0;
  408.         index--;
  409.         /* If it's at least a two-digit reference, like \34, it might
  410.            either be a 3-digit octal escape (\123) or a 2-digit
  411.            decimal memory reference (\34) */
  412.  
  413.         if ( (index+1) <pattern_len && 
  414.              (pcre_ctypes[ pattern[index+1] ] & ctype_digit) )
  415.         {
  416.             if ( (index+2) <pattern_len && 
  417.                  (pcre_ctypes[ pattern[index+2] ] & ctype_odigit) &&
  418.                  (pcre_ctypes[ pattern[index+1] ] & ctype_odigit) &&
  419.                  (pcre_ctypes[ pattern[index  ] ] & ctype_odigit)
  420.                 )
  421.             {
  422.                 /* 3 octal digits */
  423.                 value= 8*8*(pattern[index  ]-'0') +
  424.                     8*(pattern[index+1]-'0') +
  425.                     (pattern[index+2]-'0');
  426.                 if (value>255)
  427.                 {
  428.                     PyErr_SetString(ErrorObject, "octal value out of range");
  429.                     return NULL;
  430.                 }
  431.                 *indexptr = index+3;
  432.                 return Py_BuildValue("c", (unsigned char)value);
  433.             }
  434.             else
  435.             {
  436.                 /* 2-digit form, so it's a memory reference */
  437.                 value= 10*(pattern[index  ]-'0') +
  438.                     (pattern[index+1]-'0');
  439.                 if (value<1 || EXTRACT_MAX<=value)
  440.                 {
  441.                     PyErr_SetString(ErrorObject, "memory reference out of range");
  442.                     return NULL;
  443.                 }
  444.                 *typeptr = MEMORY_REFERENCE;
  445.                 *indexptr = index+2;
  446.                 return Py_BuildValue("i", value);
  447.             }
  448.         }
  449.         else 
  450.         {
  451.             /* Single-digit form, like \2, so it's a memory reference */
  452.             *typeptr = MEMORY_REFERENCE;
  453.             *indexptr = index+1;
  454.             return Py_BuildValue("i", pattern[index]-'0');
  455.         }
  456.     }
  457.     break;
  458.  
  459.     default:
  460.       /* It's some unknown escape like \s, so return a string containing
  461.          \s */
  462.         *typeptr = STRING;
  463.         *indexptr = index;
  464.         return Py_BuildValue("s#", pattern+index-2, 2);
  465.     }
  466. }
  467.  
  468. static PyObject *
  469. PyPcre_expand(self, args)
  470.     PyObject *self;
  471.     PyObject *args;
  472. {
  473.     PyObject *results, *match_obj;
  474.     PyObject *repl_obj, *newstring;
  475.     unsigned char *repl;
  476.     int size, total_len, i, start, pos;
  477.  
  478.     if (!PyArg_ParseTuple(args, "OS", &match_obj, &repl_obj)) 
  479.         return NULL;
  480.  
  481.     repl=(unsigned char *)PyString_AsString(repl_obj);
  482.     size=PyString_Size(repl_obj);
  483.     results=PyList_New(0);
  484.     if (results==NULL) return NULL;
  485.     for(start=total_len=i=0; i<size; i++)
  486.     {
  487.         if (repl[i]=='\\')
  488.         {
  489.             PyObject *value;
  490.             int escape_type;
  491.  
  492.             if (start!=i)
  493.             {
  494.                 int status;
  495.                 PyObject *s = PyString_FromStringAndSize(
  496.                     (char *)repl+start, i-start);
  497.                 if (s == NULL) {
  498.                     Py_DECREF(results);
  499.                     return NULL;
  500.                 }
  501.                 status = PyList_Append(results, s);
  502.                 Py_DECREF(s);
  503.                 if (status < 0) {
  504.                     Py_DECREF(results);
  505.                     return NULL;
  506.                 }
  507.                 total_len += i-start;
  508.             }
  509.             i++;
  510.             value=PyPcre_expand_escape(repl, size, &i, &escape_type);
  511.             if (value==NULL)
  512.             {
  513.                 /* PyPcre_expand_escape triggered an exception of some sort,
  514.                    so just return */
  515.                 Py_DECREF(results);
  516.                 return NULL;
  517.             }
  518.             switch (escape_type)
  519.             {
  520.             case (CHAR):
  521.                 PyList_Append(results, value);
  522.                 total_len += PyString_Size(value);
  523.                 break;
  524.             case(MEMORY_REFERENCE):
  525.             {
  526.                 PyObject *r, *tuple, *result;
  527.                 r=PyObject_GetAttrString(match_obj, "group");
  528.                 if (r == NULL) {
  529.                     Py_DECREF(results);
  530.                     return NULL;
  531.                 }
  532.                 tuple=PyTuple_New(1);
  533.                 Py_INCREF(value);
  534.                 PyTuple_SetItem(tuple, 0, value);
  535.                 result=PyEval_CallObject(r, tuple);
  536.                 Py_DECREF(r); Py_DECREF(tuple);
  537.                 if (result==NULL)
  538.                 {
  539.                     /* The group() method triggered an exception of some sort */
  540.                     Py_DECREF(results);
  541.                     Py_DECREF(value);
  542.                     return NULL;
  543.                 }
  544.                 if (result==Py_None)
  545.                 {
  546.                     char message[50];
  547.                     sprintf(message, 
  548.                         "group did not contribute to the match");
  549.                     PyErr_SetString(ErrorObject, 
  550.                             message);
  551.                     Py_DECREF(result);
  552.                     Py_DECREF(value);
  553.                     Py_DECREF(results);
  554.                     return NULL;
  555.                 }
  556.                 /* typecheck that it's a string! */
  557.                 if (!PyString_Check(result))
  558.                 {
  559.                     Py_DECREF(results);
  560.                     Py_DECREF(result);
  561.                     PyErr_SetString(ErrorObject, 
  562.                             "group() must return a string value for replacement");
  563.                     return NULL;
  564.                 }
  565.                 PyList_Append(results, result);
  566.                 total_len += PyString_Size(result);
  567.                 Py_DECREF(result);
  568.             }
  569.             break;
  570.             case(STRING):
  571.               {
  572.                 PyList_Append(results, value);
  573.                 total_len += PyString_Size(value);
  574.                 break;
  575.               }
  576.             default:
  577.                 Py_DECREF(results);
  578.                 PyErr_SetString(ErrorObject, 
  579.                         "bad escape in replacement");
  580.                 return NULL;
  581.             }
  582.             Py_DECREF(value);
  583.             start=i;
  584.             i--; /* Decrement now, because the 'for' loop will increment it */
  585.         }
  586.     } /* endif repl[i]!='\\' */
  587.  
  588.     if (start!=i)
  589.     {
  590.         int status;
  591.         PyObject *s = PyString_FromStringAndSize((char *)repl+start, 
  592.                              i-start);
  593.         if (s == NULL) {
  594.             Py_DECREF(results);
  595.             return NULL;
  596.         }
  597.         status = PyList_Append(results, s);
  598.         Py_DECREF(s);
  599.         if (status < 0) {
  600.             Py_DECREF(results);
  601.             return NULL;
  602.         }
  603.         total_len += i-start;
  604.     }
  605.  
  606.     /* Whew!  Now we've constructed a list containing various pieces of
  607.        strings that will make up our final result.  So, iterate over 
  608.        the list concatenating them.  A new string measuring total_len
  609.        bytes is allocated and filled in. */
  610.      
  611.     newstring=PyString_FromStringAndSize(NULL, total_len);
  612.     if (newstring==NULL)
  613.     {
  614.         Py_DECREF(results);
  615.         return NULL;
  616.     }
  617.  
  618.     repl=(unsigned char *)PyString_AsString(newstring);
  619.     for (pos=i=0; i<PyList_Size(results); i++)
  620.     {
  621.         PyObject *item=PyList_GetItem(results, i);
  622.         memcpy(repl+pos, PyString_AsString(item), PyString_Size(item) );
  623.         pos += PyString_Size(item);
  624.     }
  625.     Py_DECREF(results);
  626.     return newstring;
  627. }
  628.  
  629.  
  630. /* List of functions defined in the module */
  631.  
  632. static PyMethodDef pcre_methods[] = {
  633.     {"pcre_compile",        PyPcre_compile,        1},
  634.     {"pcre_expand",        PyPcre_expand,        1},
  635.     {NULL,        NULL}        /* sentinel */
  636. };
  637.  
  638.  
  639. /*
  640.  * Convenience routine to export an integer value.
  641.  * For simplicity, errors (which are unlikely anyway) are ignored.
  642.  */
  643.  
  644. static void
  645. insint(d, name, value)
  646.     PyObject * d;
  647.     char * name;
  648.     int value;
  649. {
  650.     PyObject *v = PyInt_FromLong((long) value);
  651.     if (v == NULL) {
  652.         /* Don't bother reporting this error */
  653.         PyErr_Clear();
  654.     }
  655.     else {
  656.         PyDict_SetItemString(d, name, v);
  657.         Py_DECREF(v);
  658.     }
  659. }
  660.  
  661.  
  662. /* Initialization function for the module (*must* be called initpcre) */
  663.  
  664. DL_EXPORT(void)
  665. initpcre()
  666. {
  667.     PyObject *m, *d;
  668.  
  669.     /* Create the module and add the functions */
  670.     m = Py_InitModule("pcre", pcre_methods);
  671.  
  672.     /* Add some symbolic constants to the module */
  673.     d = PyModule_GetDict(m);
  674.     ErrorObject = PyString_FromString("pcre.error");
  675.     PyDict_SetItemString(d, "error", ErrorObject);
  676.  
  677.     /* Insert the flags */
  678.     insint(d, "IGNORECASE", PCRE_CASELESS);
  679.     insint(d, "ANCHORED", PCRE_ANCHORED);
  680.     insint(d, "MULTILINE", PCRE_MULTILINE);
  681.     insint(d, "DOTALL", PCRE_DOTALL);
  682.     insint(d, "VERBOSE", PCRE_EXTENDED);
  683.     insint(d, "LOCALE", PCRE_LOCALE);
  684.     
  685.     /* Check for errors */
  686.     if (PyErr_Occurred())
  687.         Py_FatalError("can't initialize module pcre");
  688. }
  689.  
  690.